home *** CD-ROM | disk | FTP | other *** search
/ Turnbull China Bikeride / Turnbull China Bikeride - Disc 2.iso / STUTTGART / TEMP / GNU / bison / !Root next >
Text File  |  1995-06-28  |  8KB  |  170 lines
  1. Top
  2. Previous: <(dir)=>dir> * Next: <Introduction=>Introducti> * Up: <(dir)=>dir>
  3.  
  4. #Wrap on
  5.  
  6. This manual documents version 1.24 of Bison.
  7.  
  8. #Wrap off
  9. <Introduction=>Introducti>:      
  10. <Conditions=>Conditions>:        
  11. <Copying=>Copying>:           The GNU General Public License says
  12.                         how you can copy and share Bison
  13.  
  14. Tutorial sections:
  15. <Concepts=>Concepts>:          Basic concepts for understanding Bison.
  16. <Examples=>Examples>:          Three simple explained examples of using Bison.
  17.  
  18. Reference sections:
  19. <Grammar File=>GrammarFil>:      Writing Bison declarations and rules.
  20. <Interface=>Interface>:         C-language interface to the parser function {fCode}yyparse{f}.
  21. <Algorithm=>Algorithm>:         How the Bison parser works at run-time.
  22. <Error Recovery=>ErrorRecov>:    Writing rules for error recovery.
  23. <Context Dependency=>ContextDep>:  What to do if your language syntax is too
  24.                         messy for Bison to handle straightforwardly.
  25. <Debugging=>Debugging>:         Debugging Bison parsers that parse wrong.
  26. <Invocation=>Invocation>:        How to run Bison (to produce the parser source file).
  27. <Table of Symbols=>TableofSym>:  All the keywords of the Bison language are explained.
  28. <Glossary=>Glossary>:          Basic concepts are explained.
  29. <Index=>Index>:             Cross-references to the text.
  30.  
  31.  --- The Detailed Node Listing ---
  32.  
  33. The Concepts of Bison
  34.  
  35. <Language and Grammar=>Languagean>:  Languages and context-free grammars,
  36.                             as mathematical ideas.
  37. <Grammar in Bison=>GrammarinB>:  How we represent grammars for Bison's sake.
  38. <Semantic Values=>SemanticVa>:   Each token or syntactic grouping can have
  39.                         a semantic value (the value of an integer,
  40.                         the name of an identifier, etc.).
  41. <Semantic Actions=>SemanticAc>:  Each rule can have an action containing C code.
  42. <Bison Parser=>BisonParse>:      What are Bison's input and output,
  43.                         how is the output used?
  44. <Stages=>Stages>:            Stages in writing and running Bison grammars.
  45. <Grammar Layout=>GrammarLay>:    Overall structure of a Bison grammar file.
  46.  
  47. Examples
  48.  
  49. <RPN Calc=>RPNCalc>:          Reverse polish notation calculator;
  50.                         a first example with no operator precedence.
  51. <Infix Calc=>InfixCalc>:        Infix (algebraic) notation calculator.
  52.                         Operator precedence is introduced.
  53. <Simple Error Recovery=>SimpleErro>:  Continuing after syntax errors.
  54. <Multi-function Calc=>Multifunct>:    Calculator with memory and trig functions.
  55.                         It uses multiple data-types for semantic values.
  56. <Exercises=>Exercises>:         Ideas for improving the multi-function calculator.
  57.  
  58. Reverse Polish Notation Calculator
  59.  
  60. <Decls=>RpcalcDecl>:  Bison and C declarations for rpcalc.
  61. <Rules=>RpcalcRule>:  Grammar Rules for rpcalc, with explanation.
  62. <Lexer=>RpcalcLexe>:  The lexical analyzer.
  63. <Main=>RpcalcMain>:    The controlling function.
  64. <Error=>RpcalcErro>:  The error reporting function.
  65. <Gen=>RpcalcGen>:      Running Bison on the grammar file.
  66. <Comp=>RpcalcComp>: Run the C compiler on the output code.
  67.  
  68. Grammar Rules for {fCode}rpcalc{f}
  69.  
  70. <Rpcalc Input=>RpcalcInpu>:      
  71. <Rpcalc Line=>RpcalcLine>:       
  72. <Rpcalc Expr=>RpcalcExpr>:       
  73.  
  74. Multi-Function Calculator: {fCode}mfcalc{f}
  75.  
  76. <Decl=>MfcalcDecl>:      Bison declarations for multi-function calculator.
  77. <Rules=>MfcalcRule>:    Grammar rules for the calculator.
  78. <Symtab=>MfcalcSymt>:  Symbol table management subroutines.
  79.  
  80. Bison Grammar Files
  81.  
  82. <Grammar Outline=>GrammarOut>:   Overall layout of the grammar file.
  83. <Symbols=>Symbols>:           Terminal and nonterminal symbols.
  84. <Rules=>Rules>:             How to write grammar rules.
  85. <Recursion=>Recursion>:         Writing recursive rules.
  86. <Semantics=>Semantics>:         Semantic values and actions.
  87. <Declarations=>Declaratio>:      All kinds of Bison declarations are described here.
  88. <Multiple Parsers=>MultiplePa>:  Putting more than one Bison parser in one program.
  89.  
  90. Outline of a Bison Grammar
  91.  
  92. <C Declarations=>CDeclarati>:    Syntax and usage of the C declarations section.
  93. <Bison Declarations=>BisonDecla>:  Syntax and usage of the Bison declarations section.
  94. <Grammar Rules=>GrammarRul>:     Syntax and usage of the grammar rules section.
  95. <C Code=>CCode>:            Syntax and usage of the additional C code section.
  96.  
  97. Defining Language Semantics
  98.  
  99. <Value Type=>ValueType>:        Specifying one data type for all semantic values.
  100. <Multiple Types=>MultipleTy>:    Specifying several alternative data types.
  101. <Actions=>Actions>:           An action is the semantic definition of a grammar rule.
  102. <Action Types=>ActionType>:      Specifying data types for actions to operate on.
  103. <Mid-Rule Actions=>MidRuleAct>:  Most actions go at the end of a rule.
  104.                       This says when, why and how to use the exceptional
  105.                         action in the middle of a rule.
  106.  
  107. Bison Declarations
  108.  
  109. <Token Decl=>TokenDecl>:        Declaring terminal symbols.
  110. <Precedence Decl=>Precedence>:   Declaring terminals with precedence and associativity.
  111. <Union Decl=>UnionDecl>:        Declaring the set of all semantic value types.
  112. <Type Decl=>TypeDecl>:         Declaring the choice of type for a nonterminal symbol.
  113. <Expect Decl=>ExpectDecl>:       Suppressing warnings about shift\/reduce conflicts.
  114. <Start Decl=>StartDecl>:        Specifying the start symbol.
  115. <Pure Decl=>PureDecl>:         Requesting a reentrant parser.
  116. <Decl Summary=>DeclSummar>:      Table of all Bison declarations.
  117.  
  118. Parser C-Language Interface
  119.  
  120. <Parser Function=>ParserFunc>:   How to call {fCode}yyparse{f} and what it returns.
  121. <Lexical=>Lexical>:           You must supply a function {fCode}yylex{f} 
  122.                         which reads tokens.
  123. <Error Reporting=>ErrorRepor>:   You must supply a function {fCode}yyerror{f}.
  124. <Action Features=>ActionFeat>:   Special features for use in actions.
  125.  
  126. The Lexical Analyzer Function {fCode}yylex{f}
  127.  
  128. <Calling Convention=>CallingCon>:  How {fCode}yyparse{f} calls {fCode}yylex{f}.
  129. <Token Values=>TokenValue>:      How {fCode}yylex{f} must return the semantic value
  130.                         of the token it has read.
  131. <Token Positions=>TokenPosit>:   How {fCode}yylex{f} must return the text position
  132.                         (line number, etc.) of the token, if the
  133.                          actions want that.
  134. <Pure Calling=>PureCallin>:      How the calling convention differs
  135.                         in a pure parser (\*Note <Pure Decl=>PureDecl>: A Pure (Reentrant) Parser).
  136.  
  137. The Bison Parser Algorithm 
  138.  
  139. <Look-Ahead=>LookAhead>:        Parser looks one token ahead when deciding what to do.
  140. <Shift/Reduce=>ShiftReduc>:      Conflicts: when either shifting or reduction is valid.
  141. <Precedence=>Precedencf>:        Operator precedence works by resolving conflicts.
  142. <Contextual Precedence=>Contextual>:  When an operator's precedence depends on context.
  143. <Parser States=>ParserStat>:     The parser is a finite-state-machine with stack.
  144. <Reduce/Reduce=>ReduceRedu>:     When two rules are applicable in the same situation.
  145. <Mystery Conflicts=>MysteryCon>:  Reduce\/reduce conflicts that look unjustified.
  146. <Stack Overflow=>StackOverf>:    What happens when stack gets full.  How to avoid it.
  147.  
  148. Operator Precedence
  149.  
  150. <Why Precedence=>WhyPrecede>:    An example showing why precedence is needed.
  151. <Using Precedence=>UsingPrece>:  How to specify precedence in Bison grammars.
  152. <Precedence Examples=>Precedencg>:  How these features are used in the previous example.
  153. <How Precedence=>HowPrecede>:    How they work.
  154.  
  155. Handling Context Dependencies
  156.  
  157. <Semantic Tokens=>SemanticTo>:   Token parsing can depend on the semantic context.
  158. <Lexical Tie-ins=>LexicalTie>:   Token parsing can depend on the syntactic context.
  159. <Tie-in Recovery=>TieinRecov>:   Lexical tie-ins have implications for how
  160.                         error recovery rules must be written.
  161.  
  162. Invoking Bison
  163.  
  164. <Bison Options=>BisonOptio>:     All the options described in detail, 
  165.             in alphabetical order by short options.
  166. <Option Cross Key=>OptionCros>:  Alphabetical list of long options.
  167. <VMS Invocation=>VMSInvocat>:    Bison command syntax on VMS.
  168. #Wrap on
  169.  
  170.